#!/usr/bin/env python

import Logs, sys, Options

def configure(conf):
    conf.DEFINE('HAVE_CCAN', 1)
    conf.CHECK_HEADERS('err.h')
    conf.CHECK_HEADERS('byteswap.h')
    conf.CHECK_FUNCS('bswap_64', link=False, headers="byteswap.h")
    conf.CHECK_CODE('int __attribute__((cold)) func(int x) { return x; }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_COLD')
    conf.CHECK_CODE('int __attribute__((const)) func(int x) { return x; }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_CONST')
    conf.CHECK_CODE('void __attribute__((noreturn)) func(int x) { exit(x); }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_NORETURN')
    conf.CHECK_CODE('void __attribute__((format(__printf__, 1, 2))) func(const char *fmt, ...) { }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_PRINTF')
    conf.CHECK_CODE('int __attribute__((unused)) func(int x) { return x; }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_UNUSED')
    conf.CHECK_CODE('int __attribute__((used)) func(int x) { return x; }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_ATTRIBUTE_USED')
    # We try to use headers for a compile-time test.
    conf.CHECK_CODE(code = """#ifdef __BYTE_ORDER
                        #define B __BYTE_ORDER
                        #elif defined(BYTE_ORDER)
                        #define B BYTE_ORDER
                        #endif

                        #ifdef __LITTLE_ENDIAN
                        #define LITTLE __LITTLE_ENDIAN
                        #elif defined(LITTLE_ENDIAN)
                        #define LITTLE LITTLE_ENDIAN
                        #endif

                        #if !defined(LITTLE) || !defined(B) || LITTLE != B
                        #error Not little endian.
                        #endif""",
                           headers="endian.h sys/endian.h",
                           define="HAVE_LITTLE_ENDIAN")
    conf.CHECK_CODE(code = """#ifdef __BYTE_ORDER
                        #define B __BYTE_ORDER
                        #elif defined(BYTE_ORDER)
                        #define B BYTE_ORDER
                        #endif

                        #ifdef __BIG_ENDIAN
                        #define BIG __BIG_ENDIAN
                        #elif defined(BIG_ENDIAN)
                        #define BIG BIG_ENDIAN
                        #endif

                        #if !defined(BIG) || !defined(B) || BIG != B
                        #error Not big endian.
                        #endif""",
                           headers="endian.h sys/endian.h",
                           define="HAVE_BIG_ENDIAN")

    if not conf.CONFIG_SET("HAVE_BIG_ENDIAN") and not conf.CONFIG_SET("HAVE_LITTLE_ENDIAN"):
        # That didn't work!  Do runtime test.
        conf.CHECK_CODE("""union { int i; char c[sizeof(int)]; } u;
	  u.i = 0x01020304;
	  return u.c[0] == 0x04 && u.c[1] == 0x03 && u.c[2] == 0x02 && u.c[3] == 0x01 ? 0 : 1;""",
                        addmain=True, execute=True,
                        define='HAVE_LITTLE_ENDIAN',
                        msg="Checking for HAVE_LITTLE_ENDIAN - runtime")
        conf.CHECK_CODE("""union { int i; char c[sizeof(int)]; } u;
	  u.i = 0x01020304;
	  return u.c[0] == 0x01 && u.c[1] == 0x02 && u.c[2] == 0x03 && u.c[3] == 0x04 ? 0 : 1;""",
                        addmain=True, execute=True,
                        define='HAVE_BIG_ENDIAN',
                        msg="Checking for HAVE_BIG_ENDIAN - runtime")

    # Extra sanity check.
    if conf.CONFIG_SET("HAVE_BIG_ENDIAN") == conf.CONFIG_SET("HAVE_LITTLE_ENDIAN"):
        Logs.error("Failed endian determination.  The PDP-11 is back?")
        sys.exit(1)

    conf.CHECK_CODE('return __builtin_choose_expr(1, 0, "garbage");',
                    link=True,
                    define='HAVE_BUILTIN_CHOOSE_EXPR')
    conf.CHECK_CODE('return __builtin_clz(1) == (sizeof(int)*8 - 1) ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_CLZ')
    conf.CHECK_CODE('return __builtin_clzl(1) == (sizeof(long)*8 - 1) ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_CLZL')
    conf.CHECK_CODE('return __builtin_clzll(1) == (sizeof(long long)*8 - 1) ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_CLZLL')
    conf.CHECK_CODE('return __builtin_constant_p(1) ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_CONSTANT_P')
    conf.CHECK_CODE('return __builtin_expect(main != 0, 1) ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_EXPECT')
    conf.CHECK_CODE('return __builtin_popcountl(255L) == 8 ? 0 : 1;',
                    link=True,
                    define='HAVE_BUILTIN_POPCOUNTL')
    conf.CHECK_CODE('return __builtin_types_compatible_p(char *, int) ? 1 : 0;',
                    link=True,
                    define='HAVE_BUILTIN_TYPES_COMPATIBLE_P')
    conf.CHECK_CODE('int *foo = (int[]) { 1, 2, 3, 4 }; return foo[0] ? 0 : 1;',
                    define='HAVE_COMPOUND_LITERALS')
    conf.CHECK_CODE('struct foo { unsigned int x; int arr[]; };',
                    addmain=False, link=False,
                    define='HAVE_FLEXIBLE_ARRAY_MEMBER')
    conf.CHECK_CODE("""#include <ctype.h>
	  int main(void) { return isblank(' ') ? 0 : 1; }""",
                    link=True, addmain=False, add_headers=False,
                    define='HAVE_ISBLANK')
    conf.CHECK_CODE('int x = 1; __typeof__(x) i; i = x; return i == x ? 0 : 1;',
                    link=True,
                    define='HAVE_TYPEOF')
    conf.CHECK_CODE('int __attribute__((warn_unused_result)) func(int x) { return x; }',
                    addmain=False, link=False, cflags=conf.env['WERROR_CFLAGS'],
                    define='HAVE_WARN_UNUSED_RESULT')

    # backtrace could be in libexecinfo or in libc
    conf.CHECK_FUNCS_IN('backtrace backtrace_symbols', 'execinfo', checklibc=True, headers='execinfo.h')

    # Only check for FILE_OFFSET_BITS=64 if off_t is normally small:
    # use raw routines because wrappers include previous _GNU_SOURCE
    # or _FILE_OFFSET_BITS defines.
    conf.check(fragment="""#include <sys/types.h>
               int main(void) { return !(sizeof(off_t) < 8); }""",
               execute=True, msg='Checking for small off_t',
               define_name='SMALL_OFF_T')
    # Unreliable return value above, hence use define.
    if conf.CONFIG_SET('SMALL_OFF_T'):
        conf.check(fragment="""#include <sys/types.h>
                   int main(void) { return !(sizeof(off_t) >= 8); }""",
                   execute=True, msg='Checking for -D_FILE_OFFSET_BITS=64',
                   ccflags='-D_FILE_OFFSET_BITS=64',
                   define_name='HAVE_FILE_OFFSET_BITS')

def ccan_module(bld, name, deps=''):
    bld.SAMBA_SUBSYSTEM('ccan-%s' % name,
                        source=bld.path.ant_glob('%s/*.c' % name),
                        deps=deps)
    bld.env.CCAN_MODS += 'ccan-%s ' % name

def build(bld):
    bld.env.CCAN_MODS = ""

    # These have actual C files.
    ccan_module(bld, 'hash', 'ccan-build_assert')
    ccan_module(bld, 'ilog', 'ccan-compiler');
    ccan_module(bld, 'read_write_all')
    ccan_module(bld, 'str', 'ccan-build_assert')
    ccan_module(bld, 'tally', 'ccan-build_assert ccan-likely')

    # These are headers only.
    ccan_module(bld, 'array_size', 'ccan-build_assert')
    ccan_module(bld, 'asearch','ccan-typesafe_cb ccan-array_size')
    ccan_module(bld, 'build_assert')
    ccan_module(bld, 'cast', 'ccan-build_assert')
    ccan_module(bld, 'check_type', 'ccan-build_assert')
    ccan_module(bld, 'compiler')
    ccan_module(bld, 'endian')
    ccan_module(bld, 'likely', 'ccan-str')
    ccan_module(bld, 'typesafe_cb')
    ccan_module(bld, 'err', 'ccan-compiler')

    # Failtest pulls in a lot of stuff, and it's only for unit tests.
    if bld.env.DEVELOPER_MODE:
        ccan_module(bld, 'container_of', 'ccan-check_type')
        ccan_module(bld, 'htable', 'ccan-compiler')
        ccan_module(bld, 'list', 'ccan-container_of')
        ccan_module(bld, 'time')
        ccan_module(bld, 'tcon')
        ccan_module(bld, 'tlist', 'ccan-list ccan-tcon')
        ccan_module(bld, 'failtest',
                    '''
                    ccan-err ccan-hash ccan-htable ccan-list
                    ccan-read_write_all ccan-str ccan-time execinfo
                    ''')

    # This is the complete CCAN collection as one group.
    bld.SAMBA_LIBRARY('ccan',
                      source='',
                      deps=bld.env.CCAN_MODS,
                      private_library=True,
                      grouping_library=True)
